#include"stack.h"
#include"queue.h"
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
//bool isValid(char* s) {
//	int size = strlen(s);
//	ST st;
//	StackInit(&st);
//	while (*s)
//	{
//		if (*s == ')' || *s == '}' || *s == ']')
//		{
//			Push(&st, *s);
//		}
//		else
//		{
//			if (StackEmpty(&st))
//			{
//				StackDestroy(&st);
//				return false;
//			}
//			else if ((*s == ')' && StackTop(&st) == '(')
//				|| (*s == '}' && StackTop(&st) == '{')
//				|| (*s == ']' && StackTop(&st) == '['))
//			{
//
//				Pop(&st);
//			}
//		}
//		s++;
//	}
//	bool real = (st.Top == -1);
//	StackDestroy(&st);
//	return real;
//}
//int main()
//{
//
//	Qe q;
//	QueueInit(&q);
//	Queuepush(&q, 22);
//	QeDataType n =  QueueFront(&q);
//	QueuePop(&q);
//	QeDataType n1 = QueueFront(&q);
//	QeDataType s = QueueSize(&q);
//	printf("%d %d %d", n,s,n1);
//	return 0;
//}



//
//typedef struct {
//	Qe q1;
//	Qe q2;
//} MyStack;
//
//
//MyStack* myStackCreate() {
//	MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
//	QueueInit(&pst->q1);
//	QueueInit(&pst->q2);
//	return pst;
//}
//
//void myStackPush(MyStack* obj, int x) {
//	if (!QueueEmpty(&obj->q1))
//	{
//		Queuepush(&obj->q1, x);
//	}
//	else
//	{
//		Queuepush(&obj->q2, x);
//	}
//}
//
//int myStackPop(MyStack* obj) {
//	Qe* unemptyQe = &obj->q2;
//	Qe* emptyQe = &obj->q1;
//	if (!QueueEmpty(&obj->q1))
//	{
//		unemptyQe = &obj->q1;
//		emptyQe = &obj->q2;
//	}
//	while (QueueSize(unemptyQe) > 1)
//	{
//		Queuepush(emptyQe, QueueFront(unemptyQe));
//		QueuePop(unemptyQe);
//	}
//	int unemptyQedata = QueueFront(unemptyQe);
//	QueuePop(unemptyQe);
//	return unemptyQedata;
//}
//
//int myStackTop(MyStack* obj) {
//	if (!QueueEmpty(&obj->q1))
//	{
//		return QueueBack(&obj->q1);
//	}
//	else
//	{
//		return QueueBack(&obj->q2);
//	}
//}
//
//bool myStackEmpty(MyStack* obj) {
//	if (QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2))
//	{
//		return true;
//	}
//	else
//	{
//		return false;
//	}
//}
//
//void myStackFree(MyStack* obj) {
//	if (!QueueEmpty(&obj->q1))
//	{
//		QueueDestroy(&obj->q1);
//	}
//	if (!QueueEmpty(&obj->q2))
//	{
//		QueueDestroy(&obj->q2);
//	}
//	free(obj);
//
//}
typedef struct {
    ST s1;
    ST s2;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* mq = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&mq->s1);
    StackInit(&mq->s2);
    return mq;
}

void myQueuePush(MyQueue* obj, int x) {
    if (StackEmpty(&obj->s1))
    {
        Push(&obj->s2, x);
    }
    else
    {
        Push(&obj->s1, x);
    }
}

int myQueuePop(MyQueue* obj) {
    if (StackEmpty(&obj->s1))
    {

        while (!StackEmpty(&obj->s2))
        {
            Push(&obj->s1, StackTop(&obj->s2));
            Pop(&obj->s2);
        }
        int pop = myQueuePeek(obj);
        Pop(&obj->s1);
        while (!StackEmpty(&obj->s1))
        {
            Push(&obj->s2, StackTop(&obj->s1));
            Pop(&obj->s1);
        }

        if (!StackEmpty(&obj->s1))
        {
            Pop(&obj->s1);
        }
        return pop;
    }
    else
    {

        while (!StackEmpty(&obj->s1))
        {
            Push(&obj->s2, StackTop(&obj->s1));
            Pop(&obj->s1);
        }
        int pop = myQueuePeek(obj);
        while (!StackEmpty(&obj->s2))
        {
            Push(&obj->s1, StackTop(&obj->s2));
            Pop(&obj->s2);
        }

        if (!StackEmpty(&obj->s2))
        {
            Pop(&obj->s2);
        }
        return pop;
    }

}
int myQueuePeek(MyQueue* obj) {
    ST unemptySt = obj->s1;
    ST emptySt = obj->s2;
    if (StackEmpty(&obj->s1))
    {
        unemptySt = obj->s2;
        emptySt = obj->s1;
    }
    while (!StackEmpty(&unemptySt))
    {
        Push(&emptySt, StackTop(&unemptySt));
        Pop(&unemptySt);
    }
    int peek = StackTop(&emptySt);
    while (!StackEmpty(&emptySt))
    {
        Push(&unemptySt, StackTop(&emptySt));
        Pop(&emptySt);
    }
    return peek;

}

bool myQueueEmpty(MyQueue* obj) {
    return (StackEmpty(&obj->s1) && StackEmpty(&obj->s2));
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->s1);
    StackDestroy(&obj->s2);
    free(obj);
    obj = NULL;
}
int main()
{
    
    MyQueue* mq = myQueueCreate();
    myQueuePush(mq, 1);
    myQueuePush(mq, 2);
    myQueuePeek(mq);
    myQueuePop(mq);
    myQueueEmpty(mq);
    myQueueFree(mq);
}